using System;
using System.Collections.Generic;
using ns26;
using ns27;

namespace Triton.Game.Mapping
{
	[Attribute38("Spell")]
	public class Spell : MonoBehaviour
	{
		public bool m_BlockServerEvents => method_2<bool>("m_BlockServerEvents");

		public GameObject m_ObjectContainer => method_3<GameObject>("m_ObjectContainer");

		public SpellLocation m_Location => method_2<SpellLocation>("m_Location");

		public string m_LocationTransformName => method_4("m_LocationTransformName");

		public bool m_SetParentToLocation => method_2<bool>("m_SetParentToLocation");

		public SpellFacing m_Facing => method_2<SpellFacing>("m_Facing");

		public SpellFacingOptions m_FacingOptions => method_3<SpellFacingOptions>("m_FacingOptions");

		public TARGET_RETICLE_TYPE m_TargetReticle => method_2<TARGET_RETICLE_TYPE>("m_TargetReticle");

		public List<SpellZoneTag> m_ZonesToDisable => method_3<Class270<SpellZoneTag>>("m_ZonesToDisable")?.method_25();

		public float m_ZoneLayoutDelayForDeaths => method_2<float>("m_ZoneLayoutDelayForDeaths");

		public bool m_UseFastActorTriggers => method_2<bool>("m_UseFastActorTriggers");

		public bool m_ExclusivelyUseMetadataForTargeting => method_2<bool>("m_ExclusivelyUseMetadataForTargeting");

		public SpellType m_spellType => method_2<SpellType>("m_spellType");

		public SpellStateType m_activeStateType => method_2<SpellStateType>("m_activeStateType");

		public SpellStateType m_activeStateChange => method_2<SpellStateType>("m_activeStateChange");

		public GameObject m_source => method_3<GameObject>("m_source");

		public List<GameObject> m_targets => method_3<Class271<GameObject>>("m_targets")?.method_25();

		public PowerTaskList m_taskList => method_3<PowerTaskList>("m_taskList");

		public bool m_shown => method_2<bool>("m_shown");

		public bool m_fsmSkippedFirstFrame => method_2<bool>("m_fsmSkippedFirstFrame");

		public bool m_fsmReady => method_2<bool>("m_fsmReady");

		public bool m_positionDirty => method_2<bool>("m_positionDirty");

		public bool m_orientationDirty => method_2<bool>("m_orientationDirty");

		public bool m_finished => method_2<bool>("m_finished");

		public Spell(IntPtr address, string className)
			: base(address, className)
		{
		}

		public Spell(IntPtr address)
			: this(address, "Spell")
		{
		}

		public void Awake()
		{
			method_8("Awake");
		}

		public void OnDestroy()
		{
			method_8("OnDestroy");
		}

		public void Start()
		{
			method_8("Start");
		}

		public void Update()
		{
			method_8("Update");
		}

		public SpellType GetSpellType()
		{
			return method_11<SpellType>("GetSpellType", Array.Empty<object>());
		}

		public void SetSpellType(SpellType spellType)
		{
			method_8("SetSpellType", spellType);
		}

		public bool DoesBlockServerEvents()
		{
			return method_11<bool>("DoesBlockServerEvents", Array.Empty<object>());
		}

		public SuperSpell GetSuperSpellParent()
		{
			return method_14<SuperSpell>("GetSuperSpellParent", Array.Empty<object>());
		}

		public PowerTaskList GetPowerTaskList()
		{
			return method_14<PowerTaskList>("GetPowerTaskList", Array.Empty<object>());
		}

		public Entity GetPowerSource()
		{
			return method_14<Entity>("GetPowerSource", Array.Empty<object>());
		}

		public Card GetPowerSourceCard()
		{
			return method_14<Card>("GetPowerSourceCard", Array.Empty<object>());
		}

		public Entity GetPowerTarget()
		{
			return method_14<Entity>("GetPowerTarget", Array.Empty<object>());
		}

		public Card GetPowerTargetCard()
		{
			return method_14<Card>("GetPowerTargetCard", Array.Empty<object>());
		}

		public bool CanPurge()
		{
			return method_11<bool>("CanPurge", Array.Empty<object>());
		}

		public bool ShouldReconnectIfStuck()
		{
			return method_11<bool>("ShouldReconnectIfStuck", Array.Empty<object>());
		}

		public SpellLocation GetLocation()
		{
			return method_11<SpellLocation>("GetLocation", Array.Empty<object>());
		}

		public string GetLocationTransformName()
		{
			return method_13("GetLocationTransformName");
		}

		public SpellFacing GetFacing()
		{
			return method_11<SpellFacing>("GetFacing", Array.Empty<object>());
		}

		public SpellFacingOptions GetFacingOptions()
		{
			return method_14<SpellFacingOptions>("GetFacingOptions", Array.Empty<object>());
		}

		public void SetPosition(Vector3 position)
		{
			method_8("SetPosition", position);
		}

		public void SetLocalPosition(Vector3 position)
		{
			method_8("SetLocalPosition", position);
		}

		public void SetOrientation(Quaternion orientation)
		{
			method_8("SetOrientation", orientation);
		}

		public void SetLocalOrientation(Quaternion orientation)
		{
			method_8("SetLocalOrientation", orientation);
		}

		public void UpdateTransform()
		{
			method_8("UpdateTransform");
		}

		public void UpdatePosition()
		{
			method_8("UpdatePosition");
		}

		public void UpdateOrientation()
		{
			method_8("UpdateOrientation");
		}

		public GameObject GetSource()
		{
			return method_14<GameObject>("GetSource", Array.Empty<object>());
		}

		public void SetSource(GameObject go)
		{
			method_8("SetSource", go);
		}

		public void RemoveSource()
		{
			method_8("RemoveSource");
		}

		public bool IsSource(GameObject go)
		{
			return method_11<bool>("IsSource", new object[1] { go });
		}

		public Card GetSourceCard()
		{
			return method_14<Card>("GetSourceCard", Array.Empty<object>());
		}

		public List<GameObject> GetTargets()
		{
			return method_14<Class271<GameObject>>("GetTargets", Array.Empty<object>())?.method_25();
		}

		public GameObject GetTarget()
		{
			return method_14<GameObject>("GetTarget", Array.Empty<object>());
		}

		public void AddTarget(GameObject go)
		{
			method_8("AddTarget", go);
		}

		public bool RemoveTarget(GameObject go)
		{
			return method_11<bool>("RemoveTarget", new object[1] { go });
		}

		public void RemoveAllTargets()
		{
			method_8("RemoveAllTargets");
		}

		public bool IsTarget(GameObject go)
		{
			return method_11<bool>("IsTarget", new object[1] { go });
		}

		public Card GetTargetCard()
		{
			return method_14<Card>("GetTargetCard", Array.Empty<object>());
		}

		public List<GameObject> GetVisualTargets()
		{
			return method_14<Class271<GameObject>>("GetVisualTargets", Array.Empty<object>())?.method_25();
		}

		public GameObject GetVisualTarget()
		{
			return method_14<GameObject>("GetVisualTarget", Array.Empty<object>());
		}

		public void AddVisualTarget(GameObject go)
		{
			method_8("AddVisualTarget", go);
		}

		public bool RemoveVisualTarget(GameObject go)
		{
			return method_11<bool>("RemoveVisualTarget", new object[1] { go });
		}

		public void RemoveAllVisualTargets()
		{
			method_8("RemoveAllVisualTargets");
		}

		public bool IsVisualTarget(GameObject go)
		{
			return method_11<bool>("IsVisualTarget", new object[1] { go });
		}

		public Card GetVisualTargetCard()
		{
			return method_14<Card>("GetVisualTargetCard", Array.Empty<object>());
		}

		public bool IsValidSpellTarget(Entity ent)
		{
			return method_11<bool>("IsValidSpellTarget", new object[1] { ent });
		}

		public bool IsShown()
		{
			return method_11<bool>("IsShown", Array.Empty<object>());
		}

		public void Show()
		{
			method_8("Show");
		}

		public void Hide()
		{
			method_8("Hide");
		}

		public void ActivateObjectContainer(bool enable)
		{
			method_8("ActivateObjectContainer", enable);
		}

		public bool IsActive()
		{
			return method_11<bool>("IsActive", Array.Empty<object>());
		}

		public void Activate()
		{
			method_8("Activate");
		}

		public void Reactivate()
		{
			method_8("Reactivate");
		}

		public void Deactivate()
		{
			method_8("Deactivate");
		}

		public void ForceDeactivate()
		{
			method_8("ForceDeactivate");
		}

		public void ActivateState(SpellStateType stateType)
		{
			method_8("ActivateState", stateType);
		}

		public void SafeActivateState(SpellStateType stateType)
		{
			method_8("SafeActivateState", stateType);
		}

		public bool HasUsableState(SpellStateType stateType)
		{
			return method_11<bool>("HasUsableState", new object[1] { stateType });
		}

		public SpellStateType GetActiveState()
		{
			return method_11<SpellStateType>("GetActiveState", Array.Empty<object>());
		}

		public SpellState GetFirstSpellState(SpellStateType stateType)
		{
			return method_14<SpellState>("GetFirstSpellState", new object[1] { stateType });
		}

		public List<SpellState> GetActiveStateList()
		{
			return method_14<Class271<SpellState>>("GetActiveStateList", Array.Empty<object>())?.method_25();
		}

		public bool IsFinished()
		{
			return method_11<bool>("IsFinished", Array.Empty<object>());
		}

		public void ChangeState(SpellStateType stateType)
		{
			method_8("ChangeState", stateType);
		}

		public SpellStateType GuessNextStateType()
		{
			return method_10<SpellStateType>("GuessNextStateType", new Class276.Enum20[0], Array.Empty<object>());
		}

		public SpellStateType GuessNextStateType(SpellStateType stateType)
		{
			return method_10<SpellStateType>("GuessNextStateType", new Class276.Enum20[1] { Class276.Enum20.ValueType }, new object[1] { stateType });
		}

		public bool AttachPowerTaskList(PowerTaskList taskList)
		{
			return method_11<bool>("AttachPowerTaskList", new object[1] { taskList });
		}

		public bool AddPowerTargets()
		{
			return method_11<bool>("AddPowerTargets", Array.Empty<object>());
		}

		public PowerTaskList GetLastHandledTaskList(PowerTaskList taskList)
		{
			return method_14<PowerTaskList>("GetLastHandledTaskList", new object[1] { taskList });
		}

		public bool IsHandlingLastTaskList()
		{
			return method_11<bool>("IsHandlingLastTaskList", Array.Empty<object>());
		}

		public void OnStateFinished()
		{
			method_8("OnStateFinished");
		}

		public void OnSpellFinished()
		{
			method_8("OnSpellFinished");
		}

		public void OnSpellEvent(string eventName, object eventData)
		{
			method_8("OnSpellEvent", eventName, eventData);
		}

		public void OnAttachPowerTaskList()
		{
			method_8("OnAttachPowerTaskList");
		}

		public void OnBirth(SpellStateType prevStateType)
		{
			method_8("OnBirth", prevStateType);
		}

		public void OnIdle(SpellStateType prevStateType)
		{
			method_8("OnIdle", prevStateType);
		}

		public void OnAction(SpellStateType prevStateType)
		{
			method_8("OnAction", prevStateType);
		}

		public void OnCancel(SpellStateType prevStateType)
		{
			method_8("OnCancel", prevStateType);
		}

		public void OnDeath(SpellStateType prevStateType)
		{
			method_8("OnDeath", prevStateType);
		}

		public void OnNone(SpellStateType prevStateType)
		{
			method_8("OnNone", prevStateType);
		}

		public void BuildSpellStateMap()
		{
			method_8("BuildSpellStateMap");
		}

		public void BuildFsmStateMap()
		{
			method_8("BuildFsmStateMap");
		}

		public void ChangeStateImpl(SpellStateType stateType)
		{
			method_8("ChangeStateImpl", stateType);
		}

		public void ChangeFsmState(SpellStateType stateType)
		{
			method_8("ChangeFsmState", stateType);
		}

		public void ChangeFsmStateNow(SpellStateType stateType)
		{
			method_8("ChangeFsmStateNow", stateType);
		}

		public void FinishIfNecessary()
		{
			method_8("FinishIfNecessary");
		}

		public void CallStateFunction(SpellStateType prevStateType, SpellStateType stateType)
		{
			method_8("CallStateFunction", prevStateType, stateType);
		}

		public void FireFinishedCallbacks()
		{
			method_8("FireFinishedCallbacks");
		}

		public void FireStateFinishedCallbacks(SpellStateType prevStateType)
		{
			method_8("FireStateFinishedCallbacks", prevStateType);
		}

		public void FireStateStartedCallbacks(SpellStateType prevStateType)
		{
			method_8("FireStateStartedCallbacks", prevStateType);
		}

		public void FireSpellEventCallbacks(string eventName, object eventData)
		{
			method_8("FireSpellEventCallbacks", eventName, eventData);
		}

		public bool HasStateContent(SpellStateType stateType)
		{
			return method_11<bool>("HasStateContent", new object[1] { stateType });
		}

		public bool HasOverriddenStateMethod(SpellStateType stateType)
		{
			return method_11<bool>("HasOverriddenStateMethod", new object[1] { stateType });
		}

		public string GetStateMethodName(SpellStateType stateType)
		{
			return method_13("GetStateMethodName", stateType);
		}

		public bool CanAddPowerTargets()
		{
			return method_11<bool>("CanAddPowerTargets", Array.Empty<object>());
		}

		public bool AddSinglePowerTarget()
		{
			return method_11<bool>("AddSinglePowerTarget", Array.Empty<object>());
		}

		public bool AddSinglePowerTarget_FromBlockStart(Network.HistBlockStart blockStart)
		{
			return method_11<bool>("AddSinglePowerTarget_FromBlockStart", new object[1] { blockStart });
		}

		public bool AddMultiplePowerTargets()
		{
			return method_11<bool>("AddMultiplePowerTargets", Array.Empty<object>());
		}

		public Card GetTargetCardFromPowerTask(int index, PowerTask task)
		{
			return method_14<Card>("GetTargetCardFromPowerTask", new object[2] { index, task });
		}

		public void AddTargetFromMetaData(int metaDataIndex, Card targetCard)
		{
			method_8("AddTargetFromMetaData", metaDataIndex, targetCard);
		}

		public bool CompleteMetaDataTasks(int metaDataIndex)
		{
			return method_10<bool>("CompleteMetaDataTasks", new Class276.Enum20[1] { Class276.Enum20.I4 }, new object[1] { metaDataIndex });
		}

		public void ShowImpl()
		{
			method_8("ShowImpl");
		}

		public void HideImpl()
		{
			method_8("HideImpl");
		}

		public void OnExitedNoneState()
		{
			method_8("OnExitedNoneState");
		}

		public void OnEnteredNoneState()
		{
			method_8("OnEnteredNoneState");
		}

		public void BlockZones(bool block)
		{
			method_8("BlockZones", block);
		}

		public void OnLoad()
		{
			method_8("OnLoad");
		}
	}
}
